home *** CD-ROM | disk | FTP | other *** search
/ PC Media 22 / PC MEDIA CD22.iso / share / prog / spm220e / starintf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-08  |  28.7 KB  |  1,327 lines
  1. /*
  2. ╔═════════════════════════════════════════════════════════════════════════════╗
  3. ║ NAME      : STARINTF.PAS                                                    ║
  4. ║ FUNCTION  : Interfacing functions and procedures for the serial driver      ║
  5. ║           : STARCOMM.EXE. C Language listing for STARCOMM used as a         ║
  6. ║           : simple T.S.R. BIOS, or as a DOS DEVICE DRIVER...                ║
  7. ║ VERSION   : 2.20                                                            ║
  8. ║ LANGUAGE  : TURBO C v1.0 and laters.                                        ║
  9. ║ REMARKS   : All the functions refered to be "I" DO return UN_CHECKED if they║
  10. ║           : are called whereas "Check_STARCOMM_Present" has not been called ║
  11. ║           : yet. All the functions refered "II" DO return UN_OPENED if they ║
  12. ║           : are called whereas "Open_COMM" has not been called yet.         ║
  13. ║           : Therefore, to use this library, you have to call...             ║
  14. ║           : * at the beginning of the program:                              ║
  15. ║           :   - "Check_STARCOMM_present" to check the driver is seted in RAM║
  16. ║           :   - "Open_COMM" when the driver is used as a DEVICE DRIVER, and ║
  17. ║           :     if you want to use it from the DOS interrupt 21h.           ║
  18. ║           :   - "Open_Port" to activate the needed serial ports.            ║
  19. ║           : * at the end of the program:                                    ║
  20. ║           :   - "Close_Port" to reset all modem signals to 0 and to close   ║
  21. ║           :     all the serial ports.                                       ║
  22. ║           :   - "Close_COMM" if the driver is used as a DEVICE DRIVER.      ║
  23. ║           : Please, report yourself to STAR_REF.DOC to get any information  ║
  24. ║           : you need on these procedures and functions...                   ║
  25. ║ COPYRIGHT : HETRU Fabrice 1991-1995.                                        ║
  26. ╚═════════════════════════════════════════════════════════════════════════════╝
  27. */
  28.  
  29.  
  30. #define TRUE         1
  31. #define FALSE        0
  32. #define UN_CHECKED   20
  33. #define UN_OPENED    21
  34.  
  35.  
  36. #define byte         unsigned char
  37. #define word         unsigned int
  38.  
  39.  
  40. #include <mem.h>
  41. /* CPU registers access. */
  42. #include <dos.h>
  43. union  REGS  inregs,outregs;
  44. struct SREGS segregs;
  45. /* General globals variables. */
  46. static byte RS_accessible = FALSE;     /* Is the driver loaded in memory ?   */
  47. static byte ComExist[8]; /* What serial ports do exists? (from "Port_Opened")*/
  48. static word CommPort = 0;      /* Designated port: 0 (COM1:) to 7 (COM8:)    */
  49. static word Format;
  50. static byte Voie_active, Pret, Clear_to_send, Sonnerie, Porteuse,
  51.             dDSR, dCTS, dRI, dDCD;
  52. static byte Buff_overflow, Engorgement, Parite, Stop_bit, Break_it;
  53. static unsigned BasePort1 = 0x03F8;
  54. static unsigned BasePort2 = 0x02F8;
  55. static unsigned BasePort3 = 0x03E8;
  56. static unsigned BasePort4 = 0x02E8;
  57. static byte RTS_CTS  = 1;
  58. static byte DTR_DSR  = 2;
  59. static byte BothCmde = 3;
  60. static byte RI       = 4;
  61. static byte DCD      = 5;
  62. static byte OUT1     = 6;
  63. static byte Inactif   =  0;
  64. static byte Local     = 76; /*'L'*/
  65. static byte Eloigne   = 69; /*'E'*/
  66. static byte Bilateral = 66; /*'B'*/
  67. static byte Xon  = 0x11;
  68. static byte Xoff = 0x13;
  69. static byte NonActif = 0; /* Smode0: Erroneous bytes will be stored in the */
  70.                           /* receiving buffer exactly as they are decoded. */
  71. static byte Remplace = 1; /* Smode1: U/S bytes are subtitued...            */
  72. static byte RempNULL = 2; /* Smode2: U/S bytes are lost. The lost bytes    */
  73.               /* counter is incremented for each erroneous byte*/
  74. static byte NoBreakBuff = 100; /* Pas de code de BREAK en buffer de rcp... */
  75. static byte BreakOnBuff = 200; /* Code spécial de BREAK voulu en rcp...    */
  76. /* Variables for STARCOMM used as a DEVICE DRIVER. */
  77. static char NomDevice[9] = {'C','O','M','M',' ',' ',' ',' ','\0'};
  78. static word handler_voie_serie;
  79. static char port_ouvert = FALSE;
  80. /* Computer architectural type. */
  81. static byte Type_PC = 1;
  82. static byte Type_XT = 2;
  83. static byte Type_AT = 3;
  84. static byte PS2_PC  = 4;
  85. static byte PS2_AT  = 5;
  86.  
  87.  
  88. /* ========= SPECIFICS PROCEDURES FOR THE LIBRARY VERSION OF S.M. ========== */
  89. /* void Set_SCL(void);  */
  90. /* void UnSetSCL(void); */
  91. /* void SCLservs(void); */
  92.  
  93.  
  94. /* ====================== BIOS INTERRUPT 14h PROCEDURES ==================== */
  95. byte Version(char *NumVer)
  96.   {
  97.   if (RS_accessible)
  98.     {
  99.     inregs.h.ah = 6;
  100.     int86(0x14,&inregs,&outregs);
  101.     NumVer[0] = outregs.h.al;
  102.     NumVer[1] = '.';
  103.     outregs.x.ax = outregs.x.di;
  104.     NumVer[2] = outregs.h.ah;
  105.     NumVer[3] = outregs.h.al;
  106.     NumVer[4] = 0;
  107.     return(TRUE);
  108.     }
  109.   else
  110.     {
  111.     NumVer[0] = 0;
  112.     return(UN_CHECKED);
  113.     }
  114.   }
  115.  
  116.  
  117. byte Open_Port()
  118.   {
  119.   if (RS_accessible)
  120.     {
  121.     inregs.h.ah = 7;
  122.     inregs.h.al = 0;
  123.     inregs.x.dx = CommPort;
  124.     int86(0x14,&inregs,&outregs);
  125.     return(outregs.h.ah);
  126.     }
  127.   else return(UN_CHECKED);
  128.   }
  129.  
  130.  
  131. byte OpenPort_Buff(word Segment, word Offset, word Taille_in, word Taille_out)
  132.   {
  133.   if (RS_accessible)
  134.     {
  135.     inregs.h.ah = 7;
  136.     inregs.h.al = 6;
  137.     inregs.x.dx = CommPort;
  138.     segregs.es = Segment;
  139.     inregs.x.di = Offset;
  140.     inregs.x.bx = Taille_in;
  141.     inregs.x.cx = Taille_out;
  142.     int86(0x14,&inregs,&outregs);
  143.     return(outregs.h.ah);
  144.     }
  145.   else return(UN_CHECKED);
  146.   }
  147.  
  148.  
  149. byte Close_Port(byte ProtegeBuff)
  150.   {
  151.   if (RS_accessible)
  152.     {
  153.     inregs.h.ah = 7;
  154.     if (ProtegeBuff) inregs.h.al = 1; else inregs.h.al = 7;
  155.     inregs.x.dx = CommPort;
  156.     int86(0x14,&inregs,&outregs);
  157.     return(outregs.h.ah);
  158.     }
  159.   else return(UN_CHECKED);
  160.   }
  161.  
  162.  
  163. byte Port_Opened()
  164.   {
  165.   if (RS_accessible)
  166.     {
  167.     inregs.h.ah = 7;
  168.     inregs.h.al = 2;
  169.     inregs.x.dx = CommPort;
  170.     int86(0x14,&inregs,&outregs);
  171.     if (CommPort<8)
  172.       {
  173.       if (outregs.h.ah==5) ComExist[CommPort]=FALSE;
  174.         else ComExist[CommPort]=TRUE;
  175.       }
  176.     return(outregs.h.al);
  177.     }
  178.   else return(UN_CHECKED);
  179.   }
  180.  
  181.  
  182. byte Interdit_Port()
  183.   {
  184.   if (RS_accessible)
  185.     {
  186.     inregs.h.ah = 0x0A;
  187.     inregs.h.al = 0;
  188.     inregs.x.dx = CommPort;
  189.     int86(0x14,&inregs,&outregs);
  190.     return(outregs.h.ah);
  191.     }
  192.   else return(UN_CHECKED);
  193.   }
  194.  
  195.  
  196. byte Autorise_Port()
  197.   {
  198.   if (RS_accessible)
  199.     {
  200.     inregs.h.ah = 0x0A;
  201.     inregs.h.al = 1;
  202.     inregs.x.dx = CommPort;
  203.     int86(0x14,&inregs,&outregs);
  204.     return(outregs.h.ah);
  205.     }
  206.   else return(UN_CHECKED);
  207.   }
  208.  
  209.  
  210. byte EtatVerrouilleComm(byte *Mode)
  211.   {
  212.   if (RS_accessible)
  213.     {
  214.     inregs.h.ah = 0x0A;
  215.     inregs.h.al = 6;
  216.     inregs.x.dx = CommPort;
  217.     int86(0x14,&inregs,&outregs);
  218.     *Mode = outregs.h.al;
  219.     return(outregs.h.ah);
  220.     }
  221.   else return(UN_CHECKED);
  222.   }
  223.  
  224.  
  225. byte VerrouilleComm(byte Mode)
  226.   {
  227.   if (RS_accessible)
  228.     {
  229.     inregs.h.ah = 0x0A;
  230.     inregs.h.al = Mode;
  231.     inregs.x.dx = CommPort;
  232.     int86(0x14,&inregs,&outregs);
  233.     return(outregs.h.ah);
  234.     }
  235.   else return(UN_CHECKED);
  236.   }
  237.  
  238.  
  239. byte SLOW_Ems()
  240.   {
  241.   if (RS_accessible)
  242.     {
  243.     inregs.h.ah = 7;
  244.     inregs.h.al = 3;
  245.     inregs.x.dx = CommPort;
  246.     int86(0x14,&inregs,&outregs);
  247.     return(outregs.h.ah);
  248.     }
  249.   else return(UN_CHECKED);
  250.   }
  251.  
  252.  
  253. byte FAST_Ems()
  254.   {
  255.   if (RS_accessible)
  256.     {
  257.     inregs.h.ah = 7;
  258.     inregs.h.al = 4;
  259.     inregs.x.dx = CommPort;
  260.     int86(0x14,&inregs,&outregs);
  261.     return(outregs.h.ah);
  262.     }
  263.   else return(UN_CHECKED);
  264.   }
  265.  
  266.  
  267. byte Send_SLOW()
  268.   {
  269.   if (RS_accessible)
  270.     {
  271.     inregs.h.ah = 7;
  272.     inregs.h.al = 5;
  273.     inregs.x.dx = CommPort;
  274.     int86(0x14,&inregs,&outregs);
  275.     return(outregs.h.al);
  276.     }
  277.   else return(UN_CHECKED);
  278.   }
  279.  
  280.  
  281. void Get_Ports_Adresses()
  282.   {
  283.   movedata(0x40,0x00,FP_SEG(&BasePort1),FP_OFF(&BasePort1),8);
  284.   }
  285.  
  286.  
  287. byte Infos_Uart(byte *Uart_type, word *Uart_adresse, byte *Irq,
  288.      byte *FIFO_actif, byte *Taille_FIFO)
  289.   {
  290.   if (RS_accessible)
  291.     {
  292.     inregs.h.ah = 9;
  293.     inregs.h.al = 0;
  294.     inregs.x.dx = CommPort;
  295.     int86(0x14,&inregs,&outregs);
  296.     *Uart_type = outregs.h.al;
  297.     *Uart_adresse = outregs.x.bx;
  298.     *Irq = outregs.h.ch;
  299.     if (outregs.h.cl==0)
  300.       {
  301.       *FIFO_actif = FALSE;
  302.       *Taille_FIFO = 1;
  303.       }
  304.     else
  305.       {
  306.       *FIFO_actif = TRUE;
  307.       *Taille_FIFO = outregs.h.cl;
  308.       }
  309.     return(outregs.h.ah);
  310.     }
  311.   else return(UN_CHECKED);
  312.   }
  313.  
  314.  
  315. byte Set_New_Uart(word Uart_adresse,byte Irq,byte FIFO_actif,byte Taille_FIFO)
  316.   {
  317.   if (RS_accessible)
  318.     {
  319.     inregs.h.ah = 9;
  320.     inregs.h.al = 1;
  321.     inregs.x.dx = CommPort;
  322.     inregs.x.bx = Uart_adresse;
  323.     inregs.h.ch = Irq;
  324.     if (FIFO_actif) inregs.h.cl = Taille_FIFO;
  325.       else inregs.h.cl = 0;
  326.     int86(0x14,&inregs,&outregs);
  327.     return(outregs.h.ah);
  328.     }
  329.   else return(UN_CHECKED);
  330.   }
  331.  
  332.  
  333. byte Infos_Buffs(byte *Nb_actifs, byte *Nb_maxi, word *Taille_InBuff,
  334.      word *Taille_OutBuff)
  335.   {
  336.   if (RS_accessible)
  337.     {
  338.     inregs.h.ah = 0x0D;
  339.     int86(0x14,&inregs,&outregs);
  340.     *Taille_InBuff = outregs.x.bx;
  341.     *Taille_OutBuff = outregs.x.cx;
  342.     *Nb_actifs = outregs.h.dh;
  343.     *Nb_maxi = outregs.h.dl;
  344.     return(FALSE);
  345.     }
  346.   else return(UN_CHECKED);
  347.   }
  348.  
  349.  
  350. byte Init_Port(byte longueur, byte stop_bit, byte parity, long word vitesse,
  351.      word *Taille_InBuff, word *Taille_OutBuff)
  352.   {
  353.   byte descripteur_format, vitess;
  354.  
  355.   switch (longueur)
  356.     {
  357.     case '5': {descripteur_format = 0; break;}
  358.     case '6': {descripteur_format = 1; break;}
  359.     case '7': {descripteur_format = 2; break;}
  360.     case '8': {descripteur_format = 3; break;}
  361.     default : return(TRUE);
  362.     }
  363.   switch (stop_bit)
  364.     {
  365.     case '1': break;
  366.     case '2': {descripteur_format = descripteur_format + 0x04; break;}
  367.     default : return(TRUE);
  368.     }
  369.   switch (parity)
  370.     {
  371.     case 'n':
  372.     case 'N': break;
  373.     case 'i':
  374.     case 'I': {descripteur_format = descripteur_format + 8; break;}
  375.     case 'p':
  376.     case 'P': {descripteur_format = descripteur_format + 24; break;}
  377.     case 't':
  378.     case 'T': {descripteur_format = descripteur_format + 40; break;}
  379.     case 'r':
  380.     case 'R': {descripteur_format = descripteur_format + 56; break;}
  381.     default : return(TRUE);
  382.     }
  383.   switch (vitesse)
  384.     {
  385.     case   110: {vitess = 0; break;}
  386.     case   150: {vitess = 1; break;}
  387.     case   300: {vitess = 2; break;}
  388.     case   600: {vitess = 3; break;}
  389.     case  1200: {vitess = 4; break;}
  390.     case  2400: {vitess = 5; break;}
  391.     case  4800: {vitess = 6; break;}
  392.     case  9600: {vitess = 7; break;}
  393.     case 19200: {vitess = 8; break;}
  394.     case 28800: {vitess = 9; break;}
  395.     case 38400: {vitess = 10; break;}
  396.     case 57600: {vitess = 11; break;}
  397.     case 115200: {vitess = 12; break;}
  398.     default : return(TRUE);
  399.     }
  400.   inregs.h.bl = descripteur_format;
  401.   inregs.h.bh = vitess;
  402.   inregs.x.dx = CommPort;
  403.   inregs.h.ah = 0x0B;
  404.   if (RS_accessible)
  405.     {
  406.     int86(0x14,&inregs,&outregs);
  407.     *Taille_InBuff = outregs.x.bx;
  408.     *Taille_OutBuff = outregs.x.cx;
  409.     return(FALSE);
  410.     }
  411.   else return(UN_CHECKED);
  412.   }
  413.  
  414.  
  415. byte Init_status()
  416.   {
  417.   static byte buff[3];
  418.   /* */
  419.   if (RS_accessible)
  420.     {
  421.     segregs.es = FP_SEG(&buff[0]);
  422.     inregs.x.di = FP_OFF(&buff[0]);
  423.     inregs.x.dx = CommPort;
  424.     inregs.h.ah = 0x0C;
  425.     int86x(0x14,&inregs,&outregs,&segregs);
  426.     Format = (buff[1]*256) + buff[2];
  427.     return(TRUE);
  428.     }
  429.   else return(UN_CHECKED);
  430.   }
  431.  
  432.  
  433. byte Reset_Init_status(word Format)
  434.   {
  435.   if (RS_accessible)
  436.     {
  437.     inregs.x.bx = Format;
  438.     inregs.x.dx = CommPort;
  439.     inregs.h.ah = 0x0B;
  440.     int86(0x14,&inregs,&outregs);
  441.     return(outregs.h.ah);
  442.     }
  443.   else return(UN_CHECKED);
  444.   }
  445.  
  446.  
  447. byte flush_buffers()
  448.   {
  449.   if (RS_accessible)
  450.     {
  451.     inregs.h.ah = 0x0E;
  452.     inregs.x.dx = CommPort;
  453.     int86(0x14,&inregs,&outregs);
  454.     return(TRUE);
  455.     }
  456.   else return(UN_CHECKED);
  457.   }
  458.  
  459.  
  460. byte flush_InBuff()
  461.   {
  462.   if (RS_accessible)
  463.     {
  464.     inregs.h.ah = 0x0F;
  465.     inregs.x.dx = CommPort;
  466.     int86(0x14,&inregs,&outregs);
  467.     return(TRUE);
  468.     }
  469.   else return(UN_CHECKED);
  470.   }
  471.  
  472.  
  473. byte flush_OutBuff()
  474.   {
  475.   if (RS_accessible)
  476.     {
  477.     inregs.h.ah = 0x10;
  478.     inregs.x.dx = CommPort;
  479.     int86(0x14,&inregs,&outregs);
  480.     return(TRUE);
  481.     }
  482.   else return(UN_CHECKED);
  483.   }
  484.  
  485.  
  486. byte ResetCOM_and_TimMAX(byte RdTim_MAX, byte *Old_RdTim_MAX,
  487.      byte WrTim_MAX, byte *Old_WrTim_MAX)
  488.   {
  489.   if (RS_accessible)
  490.     {
  491.     inregs.h.ah = 0x11;
  492.     inregs.h.bh = RdTim_MAX;
  493.     inregs.h.bl = WrTim_MAX;
  494.     inregs.x.dx = CommPort;
  495.     int86(0x14,&inregs,&outregs);
  496.     *Old_RdTim_MAX = outregs.h.bh;
  497.     *Old_WrTim_MAX = outregs.h.bl;
  498.     return(TRUE);
  499.     }
  500.   else return(UN_CHECKED);
  501.   }
  502.  
  503.  
  504. byte Status_Trait_Erreurs(byte *mode, byte *codeEr, byte *codeBk)
  505.   {
  506.   if (RS_accessible)
  507.     {
  508.     inregs.h.ah = 0x12;
  509.     inregs.x.dx = CommPort;
  510.     int86(0x14,&inregs,&outregs);
  511.     *mode = outregs.h.al;
  512.     *codeEr = outregs.h.bl;
  513.     *codeBk = outregs.h.bh;
  514.     return(TRUE);
  515.     }
  516.   else return(UN_CHECKED);
  517.   }
  518.  
  519.  
  520. byte Def_Trait_Erreurs(byte mode, byte code)
  521.   {
  522.   if (RS_accessible)
  523.     {
  524.     inregs.h.al = mode;
  525.     inregs.h.bl = code;
  526.     inregs.x.dx = CommPort;
  527.     inregs.h.ah = 0x13;
  528.     int86(0x14,&inregs,&outregs);
  529.     return(outregs.h.ah);
  530.     }
  531.   else return(UN_CHECKED);
  532.   }
  533.  
  534.  
  535. byte change_com_port(byte Num_port)
  536.   {
  537.   if (RS_accessible)
  538.     {
  539.     CommPort = Num_port;
  540.     inregs.x.dx = CommPort;
  541.     inregs.h.ah = 0x08;
  542.     int86(0x14,&inregs,&outregs);
  543.     return(outregs.h.ah);
  544.     }
  545.   else return(UN_CHECKED);
  546.   }
  547.  
  548.  
  549. byte Attend_Buff_ems_vide(byte Temps_maxi)
  550.   {
  551.   if (RS_accessible)
  552.     {
  553.     inregs.h.ah = 0x1B;
  554.     inregs.h.al = Temps_maxi;
  555.     inregs.x.dx = CommPort;
  556.     int86x(0x14,&inregs,&outregs,&segregs);
  557.     return(outregs.h.ah);
  558.     }
  559.   else return(UN_CHECKED);
  560.   }
  561.  
  562.  
  563. byte CheckBufferIn(word *Nb_a_lire)
  564.   {
  565.   if (RS_accessible)
  566.     {
  567.     inregs.x.dx = CommPort;
  568.     inregs.h.ah = 0x1C;
  569.     int86(0x14,&inregs,&outregs);
  570.     *Nb_a_lire = outregs.x.cx;
  571.     if ( (outregs.h.ah==0) & (outregs.h.al==0) ) return(TRUE);
  572.       else return(FALSE);
  573.     }
  574.   else return(UN_CHECKED);
  575.   }
  576.  
  577.  
  578. byte CheckBufferOut(word *Nb_libre)
  579.   {
  580.   if (RS_accessible)
  581.     {
  582.     inregs.x.dx = CommPort;
  583.     inregs.h.ah = 0x1D;
  584.     int86(0x14,&inregs,&outregs);
  585.     *Nb_libre = outregs.x.cx;
  586.     if ( (outregs.h.ah==0) & (outregs.h.al==0) ) return(TRUE);
  587.       else return(FALSE);
  588.     }
  589.   else return(UN_CHECKED);
  590.   }
  591.  
  592.  
  593. byte ReadSerie(byte *car, word nombre, word *Nb_received)
  594.   {
  595.   if (RS_accessible)
  596.     {
  597.     inregs.h.ah = 0x14;
  598.     inregs.x.cx = nombre;
  599.     segregs.es = FP_SEG(car);
  600.     inregs.x.di = FP_OFF(car);
  601.     inregs.x.dx = CommPort;
  602.     int86x(0x14,&inregs,&outregs,&segregs);
  603.     *Nb_received = outregs.x.cx;
  604.     return(outregs.h.ah);
  605.     }
  606.   else return(UN_CHECKED);
  607.   }
  608.  
  609.  
  610. byte WriteSerie(byte *car, word nombre, word *Nb_written)
  611.   {
  612.   if (RS_accessible)
  613.     {
  614.     inregs.h.ah = 0x15;
  615.     inregs.x.cx = nombre;
  616.     segregs.es = FP_SEG(car);
  617.     inregs.x.di = FP_OFF(car);
  618.     inregs.x.dx = CommPort;
  619.     int86x(0x14,&inregs,&outregs,&segregs);
  620.     *Nb_written = outregs.x.cx;
  621.     return(outregs.h.ah);
  622.     }
  623.   else return(UN_CHECKED);
  624.   }
  625.  
  626.  
  627. byte ReadCarSerie(byte *car)
  628.   {
  629.   if (RS_accessible)
  630.     {
  631.     inregs.h.ah = 0x16;
  632.     inregs.x.dx = CommPort;
  633.     int86x(0x14,&inregs,&outregs,&segregs);
  634.     *car = outregs.h.al;
  635.     return(outregs.h.ah);
  636.     }
  637.   else return(UN_CHECKED);
  638.   }
  639.  
  640.  
  641. byte WriteCarSerie(byte car)
  642.   {
  643.   if (RS_accessible)
  644.     {
  645.     inregs.h.ah = 0x17;
  646.     inregs.h.al = car;
  647.     inregs.x.dx = CommPort;
  648.     int86x(0x14,&inregs,&outregs,&segregs);
  649.     return(outregs.h.ah);
  650.     }
  651.   else return(UN_CHECKED);
  652.   }
  653.  
  654.  
  655. byte Peek_rcp(byte *car)
  656.   {
  657.   if (RS_accessible)
  658.     {
  659.     inregs.h.ah = 0x18;
  660.     inregs.x.dx = CommPort;
  661.     int86x(0x14,&inregs,&outregs,&segregs);
  662.     *car = outregs.h.al;
  663.     return(outregs.h.ah);
  664.     }
  665.   else return(UN_CHECKED);
  666.   }
  667.  
  668.  
  669. byte Poke_rcp(byte car)
  670.   {
  671.   if (RS_accessible)
  672.     {
  673.     inregs.h.ah = 0x19;
  674.     inregs.h.al = car;
  675.     inregs.x.dx = CommPort;
  676.     int86x(0x14,&inregs,&outregs,&segregs);
  677.     return(outregs.h.ah);
  678.     }
  679.   else return(UN_CHECKED);
  680.   }
  681.  
  682.  
  683. byte WriteCmde(byte *Cmde, byte nombre, byte UseDTR)
  684.   {
  685.   if (RS_accessible)
  686.     {
  687.     inregs.h.ah = 0x1A;
  688.     segregs.es = FP_SEG(Cmde);
  689.     inregs.x.di = FP_OFF(Cmde);
  690.     inregs.h.al = nombre;
  691.     inregs.h.bh = UseDTR;
  692.     inregs.x.dx = CommPort;
  693.     int86x(0x14,&inregs,&outregs,&segregs);
  694.     return(outregs.h.ah);
  695.     }
  696.   else return(UN_CHECKED);
  697.   }
  698.  
  699.  
  700. byte etat_du_modem()
  701.   {
  702.   static byte buff[10];
  703.   /* */
  704.   if (RS_accessible)
  705.     {
  706.     inregs.h.ah = 0x20;
  707.     inregs.h.al = 0;
  708.     segregs.es = FP_SEG(&buff[0]);
  709.     inregs.x.di = FP_OFF(&buff[0]);
  710.     inregs.x.dx = CommPort;
  711.     int86x(0x14,&inregs,&outregs,&segregs);
  712.     Voie_active = buff[0] + 0x30 + 1;
  713.     if (buff[1]==1) Pret = TRUE;
  714.       else Pret = FALSE;
  715.     if (buff[2]==1) Clear_to_send = TRUE;
  716.       else Clear_to_send = FALSE;
  717.     if (buff[3]==1) Sonnerie = TRUE;
  718.       else Sonnerie = FALSE;
  719.     if (buff[4]==1) Porteuse = TRUE;
  720.       else Porteuse = FALSE;
  721.     dDSR = buff[6];
  722.     dCTS = buff[7];
  723.     dRI = buff[8];
  724.     dDCD = buff[9];
  725.     if (buff[5]==1) return(TRUE);
  726.       else return(FALSE);
  727.     }
  728.   else return(UN_CHECKED);
  729.   }
  730.  
  731.  
  732. byte set_DTR()
  733.   {
  734.   if (RS_accessible)
  735.     {
  736.     inregs.h.ah = 0x20;
  737.     inregs.h.al = 1;
  738.     inregs.x.di = 0x01;
  739.     inregs.x.dx = CommPort;
  740.     int86x(0x14,&inregs,&outregs,&segregs);
  741.     return(TRUE);
  742.     }
  743.   else return(UN_CHECKED);
  744.   }
  745.  
  746.  
  747. byte clear_DTR()
  748.   {
  749.   if (RS_accessible)
  750.     {
  751.     inregs.h.ah = 0x20;
  752.     inregs.h.al = 2;
  753.     inregs.x.di = 0xFE;
  754.     inregs.x.dx = CommPort;
  755.     int86x(0x14,&inregs,&outregs,&segregs);
  756.     return(TRUE);
  757.     }
  758.   else return(UN_CHECKED);
  759.   }
  760.  
  761.  
  762. byte set_RTS()
  763.   {
  764.   if (RS_accessible)
  765.     {
  766.     inregs.h.ah = 0x20;
  767.     inregs.h.al = 1;
  768.     inregs.x.di = 0x02;
  769.     inregs.x.dx = CommPort;
  770.     int86x(0x14,&inregs,&outregs,&segregs);
  771.     return(TRUE);
  772.     }
  773.   else return(UN_CHECKED);
  774.   }
  775.  
  776.  
  777. byte clear_RTS()
  778.   {
  779.   if (RS_accessible)
  780.     {
  781.     inregs.h.ah = 0x20;
  782.     inregs.h.al = 2;
  783.     inregs.x.di = 0xFD;
  784.     inregs.x.dx = CommPort;
  785.     int86x(0x14,&inregs,&outregs,&segregs);
  786.     return(TRUE);
  787.     }
  788.   else return(UN_CHECKED);
  789.   }
  790.  
  791.  
  792. byte set_OUT1()
  793.   {
  794.   if (RS_accessible)
  795.     {
  796.     inregs.h.ah = 0x20;
  797.     inregs.h.al = 1;
  798.     inregs.x.di = 0x04;
  799.     inregs.x.dx = CommPort;
  800.     int86x(0x14,&inregs,&outregs,&segregs);
  801.     return(TRUE);
  802.     }
  803.   else return(UN_CHECKED);
  804.   }
  805.  
  806.  
  807. byte clear_OUT1()
  808.   {
  809.   if (RS_accessible)
  810.     {
  811.     inregs.h.ah = 0x20;
  812.     inregs.h.al = 2;
  813.     inregs.x.di = 0xFB;
  814.     inregs.x.dx = CommPort;
  815.     int86x(0x14,&inregs,&outregs,&segregs);
  816.     return(TRUE);
  817.     }
  818.   else return(UN_CHECKED);
  819.   }
  820.  
  821.  
  822. byte Send_break(byte duree)
  823.   {
  824.   if (RS_accessible)
  825.     {
  826.     inregs.h.bl = duree;
  827.     inregs.h.ah = 0x1E;
  828.     inregs.x.dx = CommPort;
  829.     int86(0x14,&inregs,&outregs);
  830.     return(TRUE);
  831.     }
  832.   else return(UN_CHECKED);
  833.   }
  834.  
  835.  
  836. byte Errors_Report()
  837.   {
  838.   static byte buff[5];
  839.   /* */
  840.   if (RS_accessible)
  841.     {
  842.     inregs.h.ah = 0x1F;
  843.     segregs.es = FP_SEG(&buff[0]);
  844.     inregs.x.di = FP_OFF(&buff[0]);
  845.     inregs.x.dx = CommPort;
  846.     int86x(0x14,&inregs,&outregs,&segregs);
  847.     Buff_overflow = buff[0];
  848.     Engorgement = buff[1];
  849.     Parite = buff[2];
  850.     Stop_bit = buff[3];
  851.     Break_it = buff[4];
  852.     return(outregs.h.al);
  853.     }
  854.   else return(UN_CHECKED);
  855.   }
  856.  
  857.  
  858. byte Port_free()
  859.   {
  860.   if (RS_accessible)
  861.     {
  862.     inregs.x.dx = CommPort;
  863.     inregs.h.ah = 0x25;
  864.     int86(0x14,&inregs,&outregs);
  865.     return(outregs.h.al);
  866.     }
  867.   else return(UN_CHECKED);
  868.   }
  869.  
  870.  
  871. byte HandShake_Status(byte Proto_type, byte *SendEnabled)
  872.   {
  873.   if (RS_accessible)
  874.     {
  875.     inregs.h.ah = 0x21;
  876.     inregs.h.al = Proto_type;
  877.     inregs.x.dx = CommPort;
  878.     int86(0x14,&inregs,&outregs);
  879.     *SendEnabled = (byte)outregs.x.di;
  880.     return(outregs.h.al);
  881.     }
  882.   else return(UN_CHECKED);
  883.   }
  884.  
  885.  
  886. byte HandShake_Setup(byte Proto_type, byte state)
  887.   {
  888.   if (RS_accessible)
  889.     {
  890.     inregs.h.ah = 0x22;
  891.     inregs.h.al = Proto_type;
  892.     inregs.h.bh = state;
  893.     inregs.x.dx = CommPort;
  894.     int86(0x14,&inregs,&outregs);
  895.     return(TRUE);
  896.     }
  897.   else return(UN_CHECKED);
  898.   }
  899.  
  900.  
  901. byte XonoffShaking_Status(byte *SendEnabled, byte *Nb_Xoff)
  902.   {
  903.   static byte buff[5];
  904.   /* */
  905.   if (RS_accessible)
  906.     {
  907.     inregs.h.ah = 0x23;
  908.     segregs.es = FP_SEG(&buff[0]);
  909.     inregs.x.di = FP_OFF(&buff[0]);
  910.     inregs.x.dx = CommPort;
  911.     int86x(0x14,&inregs,&outregs,&segregs);
  912.     Xon = buff[0];
  913.     Xoff = buff[1];
  914.     *Nb_Xoff = buff[2];
  915.     *SendEnabled = buff[3];
  916.     return(buff[4]);
  917.     }
  918.   else return(UN_CHECKED);
  919.   }
  920.  
  921.  
  922. byte XonoffShaking_Setup(byte state)
  923.   {
  924.   if (RS_accessible)
  925.     {
  926.     inregs.h.ah = 0x24;
  927.     inregs.h.al = state;
  928.     inregs.h.bh = Xon;
  929.     inregs.h.bl = Xoff;
  930.     inregs.x.dx = CommPort;
  931.     int86(0x14,&inregs,&outregs);
  932.     return(TRUE);
  933.     }
  934.   else return(UN_CHECKED);
  935.   }
  936.  
  937.  
  938. byte Set_routine(word Segprog, word Ofsprog, word *OldSeg, word *OldOfs)
  939.   {
  940.   if (RS_accessible)
  941.     {
  942.     inregs.h.ah = 0x26;
  943.     segregs.es = Segprog;
  944.     inregs.x.di = Ofsprog;
  945.     inregs.x.dx = CommPort;
  946.     int86x(0x14,&inregs,&outregs,&segregs);
  947.     *OldSeg = segregs.es;
  948.     *OldOfs = outregs.x.di;
  949.     return(outregs.h.al);
  950.     }
  951.   else return(UN_CHECKED);
  952.   }
  953.  
  954.  
  955. byte Unset_routine()
  956.   {
  957.   if (RS_accessible)
  958.     {
  959.     inregs.h.ah = 0x27;
  960.     inregs.x.dx = CommPort;
  961.     int86(0x14,&inregs,&outregs);
  962.     return(TRUE);
  963.     }
  964.   else return(UN_CHECKED);
  965.   }
  966.  
  967.  
  968. byte Set_err_routine(word Segprog, word Ofsprog, word *OldSeg, word *OldOfs)
  969.   {
  970.   if (RS_accessible)
  971.     {
  972.     inregs.h.ah = 0x28;
  973.     segregs.es = Segprog;
  974.     inregs.x.di = Ofsprog;
  975.     int86x(0x14,&inregs,&outregs,&segregs);
  976.     *OldSeg = segregs.es;
  977.     *OldOfs = outregs.x.di;
  978.     return(outregs.h.al);
  979.     }
  980.   else return(UN_CHECKED);
  981.   }
  982.  
  983.  
  984. byte Unset_err_routine()
  985.   {
  986.   if (RS_accessible)
  987.     {
  988.     inregs.h.ah = 0x29;
  989.     int86(0x14,&inregs,&outregs);
  990.     return(TRUE);
  991.     }
  992.   else return(UN_CHECKED);
  993.   }
  994.  
  995.  
  996. byte Verrouille()
  997.   {
  998.   if (RS_accessible)
  999.     {
  1000.     inregs.h.ah = 0x2A;
  1001.     inregs.h.al = 1;
  1002.     inregs.h.bl = 1;
  1003.     int86(0x14,&inregs,&outregs);
  1004.     return(TRUE);
  1005.     }
  1006.   else return(UN_CHECKED);
  1007.   }
  1008.  
  1009.  
  1010. byte Deverrouille()
  1011.   {
  1012.   if (RS_accessible)
  1013.     {
  1014.     inregs.h.ah = 0x2A;
  1015.     inregs.h.al = 1;
  1016.     inregs.h.bl = 0;
  1017.     int86(0x14,&inregs,&outregs);
  1018.     return(TRUE);
  1019.     }
  1020.   else return(UN_CHECKED);
  1021.   }
  1022.  
  1023.  
  1024. byte GetDeviceName()
  1025.   {
  1026.   char Nom[9];
  1027.  
  1028.   strcpy(Nom,"        ");
  1029.   if (RS_accessible)
  1030.     {
  1031.     inregs.h.ah = 0x2B;
  1032.     segregs.es = FP_SEG(&Nom[0]);
  1033.     inregs.x.di = FP_OFF(&Nom[0]);
  1034.     int86(0x14,&inregs,&outregs);
  1035.     if (outregs.h.ah==0) strcpy(NomDevice,Nom);
  1036.     return(outregs.h.ah);
  1037.     }
  1038.   else return(UN_CHECKED);
  1039.   }
  1040.  
  1041.  
  1042. byte GetPortDevice()
  1043.   {
  1044.   if (RS_accessible)
  1045.     {
  1046.     inregs.h.ah = 0x2C;
  1047.     inregs.h.al = 0;
  1048.     int86(0x14,&inregs,&outregs);
  1049.     if (outregs.h.ah==0) return(outregs.h.al); else return(outregs.h.ah);
  1050.     }
  1051.   else return(UN_CHECKED);
  1052.   }
  1053.  
  1054.  
  1055. byte ResetPortDevice()
  1056.   {
  1057.   if (RS_accessible)
  1058.     {
  1059.     inregs.h.ah = 0x2C;
  1060.     inregs.h.al = 1;
  1061.     inregs.x.dx = CommPort;
  1062.     int86(0x14,&inregs,&outregs);
  1063.     return(outregs.h.ah);
  1064.     }
  1065.   else return(UN_CHECKED);
  1066.   }
  1067.  
  1068.  
  1069. byte EmulBIOS()
  1070.   {
  1071.   if (RS_accessible)
  1072.     {
  1073.     inregs.h.ah = 0x2D;
  1074.     inregs.h.al = 0;
  1075.     int86(0x14,&inregs,&outregs);
  1076.     return(outregs.h.al);
  1077.     }
  1078.   else return(UN_CHECKED);
  1079.   }
  1080.  
  1081.  
  1082. byte SetEmulBIOS(byte status)
  1083.   {
  1084.   if (RS_accessible)
  1085.     {
  1086.     inregs.h.ah = 0x2D;
  1087.     inregs.h.al = 1;
  1088.     inregs.h.bl = status;
  1089.     int86(0x14,&inregs,&outregs);
  1090.     }
  1091.   else return(UN_CHECKED);
  1092.   }
  1093.  
  1094.  
  1095. byte OrdiType()
  1096.   {
  1097.   if (RS_accessible)
  1098.     {
  1099.     inregs.h.ah = 0x2E;
  1100.     inregs.h.al = 0;
  1101.     int86(0x14,&inregs,&outregs);
  1102.     return(outregs.h.al);
  1103.     }
  1104.   else return(UN_CHECKED);
  1105.   }
  1106.  
  1107.  
  1108. byte SetOrdiType(byte status)
  1109.   {
  1110.   if (RS_accessible)
  1111.     {
  1112.     inregs.h.ah = 0x2E;
  1113.     inregs.h.al = 1;
  1114.     inregs.h.bl = status;
  1115.     int86(0x14,&inregs,&outregs);
  1116.     }
  1117.   else return(UN_CHECKED);
  1118.   }
  1119.  
  1120.  
  1121. /* ================== DEVICE DRIVER MODE SPECIFICS PROCEDURES ============== */
  1122. word Open_COMM()
  1123.   {
  1124.   word error;
  1125.   /* */
  1126.   if (! port_ouvert)
  1127.     {
  1128.     inregs.h.ah = 0x3D;
  1129.     segregs.ds = FP_SEG(NomDevice);
  1130.     inregs.x.dx = FP_OFF(NomDevice);
  1131.     inregs.h.al = 2;
  1132.     intdosx(&inregs,&outregs,&segregs);
  1133.     if (outregs.x.cflag != 0)
  1134.       {
  1135.       port_ouvert = FALSE;
  1136.       error = outregs.x.ax;
  1137.       }
  1138.     else
  1139.       {
  1140.       handler_voie_serie = outregs.x.ax;
  1141.       port_ouvert = TRUE;
  1142.       error = 0;
  1143.       }
  1144.     }
  1145.   else error = 0;
  1146.   return(error);
  1147.   }
  1148.  
  1149.  
  1150. word Close_COMM()
  1151.   {
  1152.   if (port_ouvert)
  1153.     {
  1154.     inregs.h.ah = 0x3E;
  1155.     inregs.x.bx = handler_voie_serie;
  1156.     intdos(&inregs,&outregs);
  1157.     if (outregs.x.cflag != 0) return(outregs.x.ax);
  1158.       else
  1159.         {
  1160.         port_ouvert = FALSE;
  1161.         return(0);
  1162.         }
  1163.     }
  1164.   else return(0);
  1165.   }
  1166.  
  1167.  
  1168. byte IOStream_READ(byte *RTS_type, byte *DTR_type, byte *RI_type,
  1169.      byte *DCD_type, byte *OUT1_type, byte *Xonoff_type)
  1170.   {
  1171.   static byte buff[10];
  1172.   /* */
  1173.   if (port_ouvert)
  1174.     {
  1175.     inregs.h.ah = 0x44;
  1176.     inregs.h.al = 2;
  1177.     inregs.x.cx = 11;
  1178.     segregs.ds = FP_SEG(&buff[0]);
  1179.     inregs.x.dx = FP_OFF(&buff[0]);
  1180.     inregs.x.bx = handler_voie_serie;
  1181.     intdosx(&inregs,&outregs,&segregs);
  1182.     if (outregs.x.cflag==0)
  1183.       {
  1184.       Voie_active = buff[0] + 0x30 + 1;
  1185.       Format = (buff[1] * 256) + buff[2];
  1186.       *RTS_type  = buff[3];
  1187.       *DTR_type  = buff[4];
  1188.       *RI_type   = buff[5];
  1189.       *DCD_type  = buff[6];
  1190.       *OUT1_type = buff[7];
  1191.       *Xonoff_type = buff[8];
  1192.       Xon = buff[9];
  1193.       Xoff = buff[10];
  1194.       return(FALSE);
  1195.       }
  1196.     else return(TRUE);
  1197.     }
  1198.   else return(UN_OPENED);
  1199.   }
  1200.  
  1201.  
  1202. byte IOStream_WRITE(byte RTS_type, byte DTR_type, byte RI_type, byte DCD_type,
  1203.      byte OUT1_type, byte Xonoff_type)
  1204.   {
  1205.   static byte buff[10];
  1206.   /* */
  1207.   if (port_ouvert)
  1208.     {
  1209.     buff[0] = Voie_active - 0x30 - 1;
  1210.     inregs.x.ax = Format;
  1211.     buff[1] = inregs.h.ah;
  1212.     buff[2] = inregs.h.al;
  1213.     buff[3] = RTS_type;
  1214.     buff[4] = DTR_type;
  1215.     buff[5] = RI_type;
  1216.     buff[6] = DCD_type;
  1217.     buff[7] = OUT1_type;
  1218.     buff[8] = Xonoff_type;
  1219.     buff[9] = Xon;
  1220.     buff[10] = Xoff;
  1221.     inregs.h.ah = 0x44;
  1222.     inregs.h.al = 3;
  1223.     inregs.x.cx = 11;
  1224.     segregs.ds = FP_SEG(&buff[0]);
  1225.     inregs.x.dx = FP_OFF(&buff[0]);
  1226.     inregs.x.bx = handler_voie_serie;
  1227.     intdosx(&inregs,&outregs,&segregs);
  1228.     if (outregs.x.cflag==0) return(FALSE);
  1229.       else return(TRUE);
  1230.     }
  1231.   else return(UN_OPENED);
  1232.   }
  1233.  
  1234.  
  1235. byte CheckCOMMIn()
  1236.   {
  1237.   if (port_ouvert)
  1238.     {
  1239.     inregs.h.ah = 0x44;
  1240.     inregs.h.al = 6;
  1241.     inregs.x.bx = handler_voie_serie;
  1242.     intdos(&inregs,&outregs);
  1243.     if (outregs.h.al==0) return(FALSE);
  1244.       else return(TRUE);
  1245.     }
  1246.   else return(UN_OPENED);
  1247.   }
  1248.  
  1249.  
  1250. byte CheckCOMMOut()
  1251.   {
  1252.   if (port_ouvert)
  1253.     {
  1254.     inregs.h.ah = 0x44;
  1255.     inregs.h.al = 7;
  1256.     inregs.x.bx = handler_voie_serie;
  1257.     intdos(&inregs,&outregs);
  1258.     if (outregs.h.al==0) return(TRUE);
  1259.       else return(FALSE);
  1260.     }
  1261.   else return(UN_OPENED);
  1262.   }
  1263.  
  1264.  
  1265. int ReadCOMM(byte *car, word nombre)
  1266.   {
  1267.   if (port_ouvert)
  1268.     {
  1269.     inregs.h.ah = 0x3F;
  1270.     inregs.x.bx = handler_voie_serie;
  1271.     inregs.x.cx = nombre;
  1272.     segregs.ds = FP_SEG(car);
  1273.     inregs.x.dx = FP_OFF(car);
  1274.     intdosx(&inregs,&outregs,&segregs);
  1275.     if (outregs.x.cflag != 0) return(outregs.x.ax);
  1276.       else
  1277.         {
  1278.         if (outregs.x.ax != 0) return(0);
  1279.           else return(-1);
  1280.         }
  1281.     }
  1282.   else return(UN_OPENED);
  1283.   }
  1284.  
  1285.  
  1286. int WriteCOMM(byte *car, word nombre)
  1287.   {
  1288.   if (port_ouvert)
  1289.     {
  1290.     inregs.h.ah = 0x40;
  1291.     inregs.x.bx = handler_voie_serie;
  1292.     inregs.x.cx = nombre;
  1293.     segregs.ds = FP_SEG(car);
  1294.     inregs.x.dx = FP_OFF(car);
  1295.     intdosx(&inregs,&outregs,&segregs);
  1296.     if (outregs.x.cflag != 0) return(outregs.x.ax);
  1297.       else
  1298.         {
  1299.         if (outregs.x.ax != 0) return(0);
  1300.           else return(-1);
  1301.         }
  1302.     }
  1303.   else return(UN_OPENED);
  1304.   }
  1305.  
  1306.  
  1307. /* =============== SPECIAL PROCEDURE TO SCAN STARCOMM IN MEMORY ============ */
  1308. byte Check_STARCOMM_Present()
  1309.   {
  1310.   static byte check;
  1311.  
  1312.   check=0;
  1313.   inregs.h.ah=6;
  1314.   inregs.h.al=0;
  1315.   int86(0x14,&inregs,&outregs);
  1316.   if (outregs.h.al!=0)
  1317.     {
  1318.     RS_accessible = TRUE;
  1319.     check=1;
  1320.     }
  1321.   else RS_accessible = FALSE;
  1322.   if (RS_accessible)
  1323.     {
  1324.     if (GetDeviceName()==0) check=2;
  1325.     }
  1326.   return(check);
  1327.   }